package AnalisadorLexico;

import Principal.Erro;
import java.util.ArrayList;
import java.util.TreeMap;
import java.util.regex.*;

/**
 *
 * @author Fábio Novais
 */
public class Analisador
{

    private TreeMap<String, ArrayList<String>> _tokens;
    private String _linhaAtual;
    private ArrayList<String> _ocorrencias;
    private ArrayList<String> _palavrasReservadas;

    public Analisador()
    {
        _tokens = new TreeMap<String, ArrayList<String>>();
        _linhaAtual = "";
        IniciarPalavrasReservadas();
    }

    public TreeMap<String, ArrayList<String>> getTokens()
    {
        return _tokens;
    }

    public void setTokenS(TreeMap<String, ArrayList<String>> tokens)
    {
        _tokens = tokens;
    }

    /**
     * Inicia a lista de palavras reservadas
     */
    private void IniciarPalavrasReservadas()
    {
        _palavrasReservadas = new ArrayList<String>();
        _palavrasReservadas.add("alias");
        _palavrasReservadas.add("and");
        _palavrasReservadas.add("begin");
        _palavrasReservadas.add("BEGIN");
        _palavrasReservadas.add("break");
        _palavrasReservadas.add("case");
        _palavrasReservadas.add("class");
        _palavrasReservadas.add("def");
        _palavrasReservadas.add("defined?");
        _palavrasReservadas.add("do");
        _palavrasReservadas.add("else");
        _palavrasReservadas.add("elseif");
        _palavrasReservadas.add("END");
        _palavrasReservadas.add("end");
        _palavrasReservadas.add("ensure");
        _palavrasReservadas.add("false");
        _palavrasReservadas.add("for");
        _palavrasReservadas.add("if");
        _palavrasReservadas.add("in");
        _palavrasReservadas.add("module");
        _palavrasReservadas.add("next");
        _palavrasReservadas.add("nil");
        _palavrasReservadas.add("not");
        _palavrasReservadas.add("or");
        _palavrasReservadas.add("redo");
        _palavrasReservadas.add("rescue");
        _palavrasReservadas.add("retry");
        _palavrasReservadas.add("return");
        _palavrasReservadas.add("self");
        _palavrasReservadas.add("super");
        _palavrasReservadas.add("then");
        _palavrasReservadas.add("true");
        _palavrasReservadas.add("undef");
        _palavrasReservadas.add("unless");
        _palavrasReservadas.add("until");
        _palavrasReservadas.add("when");
        _palavrasReservadas.add("while");
        _palavrasReservadas.add("yield");
        _palavrasReservadas.add("Integer");
        _palavrasReservadas.add("Boolean");
        _palavrasReservadas.add("Object");
        _palavrasReservadas.add("String");
        _palavrasReservadas.add("Float");
    }

    public void Analisar(String linha) throws Exception
    {
        String[] linhasSplit = linha.split("%%");
        
        if (linhasSplit.length != 2)
        {
            throw new Exception(TratadorErros.ERROINESPERADO);
        }

        int numLinha =  Integer.parseInt(linhasSplit[0].toString());
        String linhaDocomment = linhasSplit[1].trim();

        if (!linhaDocomment.startsWith("#"))
        {
            return;
        }

        _linhaAtual = linhaDocomment.replace("#", "");

        _ocorrencias = ReconhecerTSTRING(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTSTRING();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDDESCRIPTION(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDDESCRIPTION();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDAUTHOR(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDAUTHOR();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDSINCE(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDSINCE();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDVERSION(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDVERSION();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDSEE(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDSEE();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDPARAM(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDPARAM();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDDEPRECATED(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDDEPRECATED();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDRETURN(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDRETURN();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTTFIXME(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTTFIXME();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTTTODO(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTTTODO();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDATE(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDATE();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTEMAIL(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTEMAIL();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTVERSION(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTVERSION();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTPARAM(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTPARAM();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTCLASS(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTCLASS();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTMETHOD(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTMETHOD();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTBOOL(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTBOOL();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTDATATYPE(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTDATATYPE();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        _ocorrencias = ReconhecerTSEP(_linhaAtual);
        if (_ocorrencias.size() > 0)
        {
            String token = Token.getTSEP();
            if (_tokens.containsKey(token))
            {
                _tokens.get(token).addAll(_ocorrencias);
            } else
            {
                _tokens.put(token, _ocorrencias);
            }
        }

        //Se sobrou caracter insere como NOMATCH e na lista de erros
        String nomatch = _linhaAtual.trim();
        if (nomatch.length() > 0)
        {
            String token = Token.getNOMATCH();
            String[] listaErros = nomatch.split(" ");
            //ArrayList<String> errosTrim = new ArrayList<String>();
            for (int i = 0; i < listaErros.length; i++)
            {
                String erroTrim = listaErros[i].trim();
               
                if (erroTrim.length() > 0)
                {
                    Erro erro = new Erro(1, numLinha,erroTrim) ;
                    //errosTrim.add(erroTrim);
                    TratadorErros.AdicionarErro(erro);
                    if (_tokens.containsKey(token))
                    {
                        _tokens.get(token).add(erroTrim);
                    } else
                    {
                        ArrayList<String> primeiro = new ArrayList<String>();
                        primeiro.add(erroTrim);
                        _tokens.put(token, primeiro);
                    }
                }
            }
             //TratadorErros._listaErros.put(numLinha, errosTrim);
        }
    }

    public ArrayList<String> ReconhecerTDDESCRIPTION(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDDESCRIPTION();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDAUTHOR(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDAUTHOR();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDSINCE(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDSINCE();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDVERSION(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDVERSION();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDSEE(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDSEE();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDPARAM(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDPARAM();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDDEPRECATED(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDDEPRECATED();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDRETURN(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDRETURN();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    /**
     *
     * @param texto a ser analisado
     * @return Uma lista com todas os padrões
     * encontrados na expressão.
     */
    public ArrayList<String> ReconhecerTSTRING(String expressao)
    {
        String expressaoRegular = ExpressaoRegular.getTSTRING();

        Pattern pattern = Pattern.compile(expressaoRegular);
        Matcher matcher = pattern.matcher(expressao.trim());

        ArrayList<String> ocorrencias = new ArrayList<String>();
        while (matcher.find())
        {
            String token = matcher.group();
            ocorrencias.add(token);
            _linhaAtual = _linhaAtual.replaceFirst(token, "");
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTTFIXME(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTTFIXME();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTTTODO(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTTTODO();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDATE(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDATE();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTVERSION(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTVERSION();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    /**
     * Reconhece um padrao de email
     * @param expressão a ser analisada
     * @return Padrão de email encontrado
     */
    public ArrayList<String> ReconhecerTEMAIL(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        expressao = expressao.replaceAll(",", "");
        String[] tokens = expressao.split(",| ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTEMAIL();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTPARAM(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            if (!_palavrasReservadas.contains(tokens[i]))
            {
                String expressaoRegular = ExpressaoRegular.getTPARAM();

                Pattern pattern = Pattern.compile(expressaoRegular);
                Matcher matcher = pattern.matcher(tokens[i].trim());

                while (matcher.find())
                {
                    String token = matcher.group();
                    _linhaAtual = _linhaAtual.replaceFirst(token, "");
                    ocorrencias.add(token);
                }
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTBOOL(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTBOOL();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTCLASS(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            if (!_palavrasReservadas.contains(tokens[i]))
            {
                String expressaoRegular = ExpressaoRegular.getTCLASS();

                Pattern pattern = Pattern.compile(expressaoRegular);
                Matcher matcher = pattern.matcher(tokens[i].trim());

                while (matcher.find())
                {
                    String token = matcher.group();
                    _linhaAtual = _linhaAtual.replaceFirst(token, "");
                    ocorrencias.add(token);
                }
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTMETHOD(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            if (!_palavrasReservadas.contains(tokens[i]))
            {
                String expressaoRegular = ExpressaoRegular.getTMETHOD();

                Pattern pattern = Pattern.compile(expressaoRegular);
                Matcher matcher = pattern.matcher(tokens[i].trim());

                while (matcher.find())
                {
                    String token = matcher.group();
                    _linhaAtual = _linhaAtual.replaceFirst(token, "");
                    ocorrencias.add(token);
                }
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTDATATYPE(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTDATATYPE();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    public ArrayList<String> ReconhecerTSEP(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTSEP();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceFirst(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    private ArrayList<String> ReconhecerTID(String expressao)
    {
        ArrayList<String> ocorrencias = new ArrayList<String>();
        String[] tokens = expressao.split(" ");
        for (int i = 0; i < tokens.length; i++)
        {
            String expressaoRegular = ExpressaoRegular.getTID();

            Pattern pattern = Pattern.compile(expressaoRegular);
            Matcher matcher = pattern.matcher(tokens[i].trim());

            while (matcher.find())
            {
                String token = matcher.group();
                _linhaAtual = _linhaAtual.replaceAll(token, "");
                ocorrencias.add(token);
            }
        }

        return ocorrencias;
    }

    /**
     * Verifica se a sequência é uma definição de método.
     * @param expressão a ser analisada
     * @return verdadeiro caso a sequência seja 
     * uma definicao de método
     */
    public boolean IsDefMethod(String expressao)
    {
        String expressao2 = expressao.trim();
        String expressaoRegular = ExpressaoRegular.getDEFMEHTOD();

        Pattern pattern = Pattern.compile(expressaoRegular);
        Matcher matcher = pattern.matcher(expressao2);

        boolean match = matcher.matches();

        return match;
    }

    /**
     * Verifica se a sequência é uma definição de classe.
     * @param expressão a ser analisada
     * @return verdadeiro caso a sequência seja
     * uma definicao de classe
     */
    public boolean IsDefClass(String expressao)
    {
        String expressaoRegular = ExpressaoRegular.getDEFCLASS();

        Pattern pattern = Pattern.compile(expressaoRegular);
        Matcher matcher = pattern.matcher(expressao);

        return matcher.matches();
    }
}
